;;; Upper CYC(R) Ontology flat-file ;;; Copyright Cycorp 1997. All rights reserved. ;;;Cycorp License Agreement ;;;Cycorp is providing this material from the Cyc(tm) Upper ;;;Ontology at no charge, for everyone to use, including ;;;commercial service use and incorporation into products. ;;;However, it is not 'Public Domain.' Please acknowledge ;;;Cycorp, 3721 Executive Center Dr., Austin, TX 78731 in ;;;any use or citation of this material, and request that each ;;;further user include a full copy of this notice as well, ;;;in any use or citation they make of the material. All ;;;these terms equally apply to renamings and other ;;;logically equivalent reformulations of the material in ;;;any natural or formal language. Cycorp intends to ;;;amend and expand the material from time to time; the ;;;latest version is available at http://www.cyc.com ;;; #$educationLevel (#$isa #$educationLevel #$BinaryPredicate) (#$arg1Isa #$educationLevel #$Person) (#$arg2Isa #$educationLevel #$EducationLevelAttribute) (#$comment #$educationLevel "(#$educationLevel PRSN LVL) means #$Person PRSN has had formal schooling up to the highest level #$EducationLevelAttribute LVL at one or more #$EducationalOrganizations. This will refer to a particular #$subAbstrac of a #$Person, not to the person as a whole lifetime #$Entity.") ;;; #$elasticityOfObject (#$isa #$elasticityOfObject #$TangibleObjectPredicate) (#$isa #$elasticityOfObject #$IntervalBasedQuantitySlot) (#$arg1Isa #$elasticityOfObject #$SolidTangibleThing) (#$arg2Isa #$elasticityOfObject #$Elasticity) (#$comment #$elasticityOfObject "(#$elasticityOfObject OBJ DEGREE) indicates how readily the solid tangible thing OBJ returns to its original shape after being deformed (but not broken). The higher the DEGREE of elasticity, the more quickly and completely the object returns to its previous shape. Billiard balls, for example, are highly elastic in this sense. A related concept is #$compressibilityOfObject.") ;;; #$elementOf (#$isa #$elementOf #$BinaryPredicate) (#$not (#$isa #$elementOf #$AsymmetricBinaryPredicate)) (#$not (#$isa #$elementOf #$SymmetricBinaryPredicate)) (#$not (#$isa #$elementOf #$AntiSymmetricBinaryPredicate)) (#$not (#$isa #$elementOf #$TransitiveBinaryPredicate)) (#$not (#$isa #$elementOf #$IrreflexiveBinaryPredicate)) (#$not (#$isa #$elementOf #$ReflexiveBinaryPredicate)) (#$arg1Isa #$elementOf #$Thing) (#$arg2Isa #$elementOf #$SetOrCollection) (#$comment #$elementOf "(#$elementOf THNG SETORCOL) means that THNG is an element of the mathematical set or collection SETORCOL. #$elementOf is a more general relation than the more-heavily-used #$isa, which is used to talk about membership in a natural kind (an element of #$Collection). #$elementOf can also be used to talk about membership in an arbitrarily-defined mathematical set (an instance of #$Set-Mathematical), such as those denoted by #$TheSet expressions.") ;;; #$emitter (#$isa #$emitter #$ActorSlot) (#$isa #$emitter #$AsymmetricBinaryPredicate) (#$isa #$emitter #$IrreflexiveBinaryPredicate) (#$genlPreds #$emitter #$providerOfMotiveForce) (#$genlPreds #$emitter #$fromLocation) (#$genlPreds #$emitter #$doneBy) (#$arg1Isa #$emitter #$Emission) (#$arg2Isa #$emitter #$PartiallyTangible) (#$comment #$emitter "The Cyc predicate #$emitter is used to identify the source of an emission. (#$emitter EMIT OBJ) means that OBJ provides the force involved in making the #$objectEmitted move from OBJ to someplace outside of OBJ. See also #$providerOfMotiveForce, #$fromLocation.") ;;; #$employedAgent (#$isa #$employedAgent #$BinaryPredicate) (#$genlPreds #$employedAgent #$agreeingAgents) (#$arg1Isa #$employedAgent #$WorkAgreement) (#$arg2Isa #$employedAgent #$Agent) (#$comment #$employedAgent "The predicate #$employedAgent identifies the particular employee who is covered by a particular work agreement. (#$employedAgent AGREE WORKER) means that AGREE is an instance of #$WorkAgreement covering the employee WORKER.") ;;; #$employeeStatus (#$isa #$employeeStatus #$BinaryPredicate) (#$arg1Isa #$employeeStatus #$Person) (#$arg1Isa #$employeeStatus #$Agent) (#$arg2Isa #$employeeStatus #$WorkStatus) (#$comment #$employeeStatus "The predicate #$employeeStatus describes a worker's job as full-time, part-time, salaried, commissioned, paid by the hour, or etc. More than one may apply. (#$employeeStatus WORKER STATUS) means that STATUS indicates the #$WorkStatus of WORKER. For example, the #$employeeStatus of an auto worker at GM probably includes the #$WorkStatus attributes #$FullTime and #$HourlyWork.") ;;; #$employees (#$isa #$employees #$AsymmetricBinaryPredicate) (#$isa #$employees #$CotemporalObjectsSlot) (#$not (#$isa #$employees #$TransitiveBinaryPredicate)) (#$genlPreds #$employees #$hasWorkers) (#$genlPreds #$employees #$affiliatedWith) (#$genlPreds #$employees #$cotemporal) (#$arg1Isa #$employees #$Agent) (#$arg2Isa #$employees #$Agent) (#$comment #$employees "The predicate #$employees relates a particular employer to one of its paid employees. (#$employees EMPLOYER WORKER) means WORKER regularly performs work for EMPLOYER, and EMPLOYER pays WORKER for that activity (often by paycheck). EMPLOYER directs the manner in which WORKER performs the work and may provide the workplace, tools, capital, and other assistance for the work. EMPLOYER is commonly an organization but may be a person. E.g., (#$employees PerryMason PaulDrake); (#$employees #$Cycorp #$Lenat). This predicate is true during all or any part of the period that the employment continues; e.g., (#$holdsIn (#$YearFn 1995) (#$employees #$CarnegieMellonUniversity #$Derthick)).") ;;; #$employingAgent (#$isa #$employingAgent #$BinaryPredicate) (#$genlPreds #$employingAgent #$agreeingAgents) (#$arg1Isa #$employingAgent #$WorkAgreement) (#$arg2Isa #$employingAgent #$Agent) (#$comment #$employingAgent "The predicate #$employingAgent identifies the employer in a particular work agreement. (#$employingAgent AGREE EMPLOYER) means that the #$Agent EMPLOYER has entered into the #$WorkAgreement AGREE with some employee, and AGREE obligates EMPLOYER to compensate that employee for specified work. See also #$Agreement, #$obligatedAgent.") ;;; #$emptiesInto (#$not (#$isa #$emptiesInto #$TransitiveBinaryPredicate)) (#$isa #$emptiesInto #$AntiTransitiveBinaryPredicate) (#$isa #$emptiesInto #$AsymmetricBinaryPredicate) (#$isa #$emptiesInto #$FunctionalSlot) (#$arg1Isa #$emptiesInto #$Stream) (#$arg2Isa #$emptiesInto #$BodyOfWater) (#$comment #$emptiesInto "The predicate #$emptiesInto is used to indicate that a particular flowing body of water disgorges into another body of water. (#$emptiesInto RIV WAT) means that the #$Stream RIV flows into WAT, an element of #$BodyOfWater. Examples: (#$emptiesInto #$AmazonRiver #$AtlanticOcean); (#$emptiesInto #$HuangHeRiver #YellowSea).") ;;; #$endToEndConnected (#$isa #$endToEndConnected #$InterExistingObjectSlot) (#$isa #$endToEndConnected #$ConnectionPredicate) (#$isa #$endToEndConnected #$SpatialPredicate) (#$isa #$endToEndConnected #$SymmetricBinaryPredicate) (#$genlPreds #$endToEndConnected #$connectedTo-Rigidly) (#$genlInverse #$endToEndConnected #$endToEndConnected) (#$genlInverse #$endToEndConnected #$connectedTo-Rigidly) (#$arg1Isa #$endToEndConnected #$Path-Simple) (#$arg2Isa #$endToEndConnected #$Path-Simple) (#$comment #$endToEndConnected "(#$endToEndConnected PATH1 PATH2) means that one end of a #$Path-Simple or a #$SimpleUnloopedSegmentOfPath, PATH1, is connected to one end of another #$Path-Simple or #$SimpleUnloopedSegmentOfPath, PATH2, end-to-end, allowing flow or transport between them. This kind of connection is not currently included as a #$JunctionOfPaths. In pipe welding, these connections are called butt welds or circumferential pipe welds.") ;;; #$endingDate (#$isa #$endingDate #$BinaryPredicate) (#$genlPreds #$endingDate #$endsDuring) (#$arg1Isa #$endingDate #$TemporalThing) (#$arg2Isa #$endingDate #$Date) (#$comment #$endingDate "(#$endingDate ?X ?Y) indicates that ?Y is a #$Date such that (#$temporallySubsumes ?Y (#$EndFn ?X)). This is NOT the same as #$endingPoint. Rather, it means that ?X stopped happening (went out of existence, etc.) sometime on that date. Note: the date is tied to a time interval on a calendar, but need not be a particular day; it might be a particular calendar month, a particular calendar year, etc.") ;;; #$endingPoint (#$isa #$endingPoint #$TemporalRelation) (#$arg1Isa #$endingPoint #$TemporalThing) (#$arg2Isa #$endingPoint #$TimePoint) (#$comment #$endingPoint "(#$endingPoint ?X ?T) indicates that ?T is the #$TimePoint at which ?X ends, the latest moment of its temporal extent.") ;;; #$endsAfterEndingOf (#$isa #$endsAfterEndingOf #$IrreflexiveBinaryPredicate) (#$isa #$endsAfterEndingOf #$ComplexTemporalRelation) (#$isa #$endsAfterEndingOf #$AsymmetricBinaryPredicate) (#$isa #$endsAfterEndingOf #$TransitiveBinaryPredicate) (#$genlPreds #$endsAfterEndingOf #$endsAfterStartingOf) (#$arg1Isa #$endsAfterEndingOf #$TemporalThing) (#$arg2Isa #$endsAfterEndingOf #$TemporalThing) (#$comment #$endsAfterEndingOf "(#$endsAfterEndingOf LATER EARLY) means that LATER ends after EARLY ends -- in Cyc terms, (#$after (#$EndFn LATER) (#$EndFn EARLY)). That is, the #$endingPoint of LATER is later than the #$endingPoint of EARLY. This implies nothing about whether LATER and EARLY overlap, or how much they overlap, except that they can't be fully #$cotemporal. Examples: rinsing while showering ends after soaping while showering; the process of hiring a contractor ends after the process of collecting bids.") ;;; #$endsAfterStartingOf (#$isa #$endsAfterStartingOf #$ComplexTemporalRelation) (#$isa #$endsAfterStartingOf #$ReflexiveBinaryPredicate) (#$not (#$isa #$endsAfterStartingOf #$TransitiveBinaryPredicate)) (#$not (#$isa #$endsAfterStartingOf #$SymmetricBinaryPredicate)) (#$not (#$isa #$endsAfterStartingOf #$AntiSymmetricBinaryPredicate)) (#$not (#$isa #$endsAfterStartingOf #$AsymmetricBinaryPredicate)) (#$arg1Isa #$endsAfterStartingOf #$TemporalThing) (#$arg2Isa #$endsAfterStartingOf #$TemporalThing) (#$comment #$endsAfterStartingOf "(#$endsAfterStartingOf ?X ?Y) means (#$after (#$EndFn ?X) (#$StartFn ?Y)). That is, the #$endingPoint of ?X is later than the #$startingPoint of ?Y. This implies nothing about whether ?X and ?Y overlap, or how much they overlap.") ;;; #$endsDuring (#$isa #$endsDuring #$ComplexTemporalRelation) (#$isa #$endsDuring #$AsymmetricBinaryPredicate) (#$not (#$isa #$endsDuring #$TransitiveBinaryPredicate)) (#$not (#$isa #$endsDuring #$SymmetricBinaryPredicate)) (#$genlPreds #$endsDuring #$endsAfterStartingOf) (#$genlPreds #$endsDuring #$temporalBoundsIntersect) (#$genlInverse #$endsDuring #$endsAfterEndingOf) (#$arg1Isa #$endsDuring #$TemporalThing) (#$arg2Isa #$endsDuring #$TemporalThing) (#$comment #$endsDuring "(#$endsDuring ?X ?Y) means ?Y covers the end of ?X, i.e. the #$endingPoint of ?X is properly contained in (#$temporalBoundsContain) ?Y. Note that ?X and ?Y don't necessarily intersect, however, if ?Y is continuous, they do.") ;;; #$endsOfPathSegment (#$isa #$endsOfPathSegment #$CotemporalObjectsSlot) (#$isa #$endsOfPathSegment #$AsymmetricBinaryPredicate) (#$genlPreds #$endsOfPathSegment #$cotemporal) (#$genlPreds #$endsOfPathSegment #$physicalParts) (#$genlInverse #$endsOfPathSegment #$onPath) (#$arg1Isa #$endsOfPathSegment #$Path-Simple) (#$arg2Isa #$endsOfPathSegment #$Thing) (#$comment #$endsOfPathSegment "(#$endsOfPathSegment PATH LOC) means that LOC is one end of the #$Path-Simple segment PATH; LOC may be either a junction or a genuine terminal-end of the path segment. This refers to the ends of any kind of simple path.") ;;; #$english (#$isa #$english #$BinaryPredicate) (#$arg1Isa #$english #$Thing) (#$arg2Isa #$english #$CycSystemString) ;;; #$equals (#$isa #$equals #$TransitiveBinaryPredicate) (#$isa #$equals #$ReflexiveBinaryPredicate) (#$isa #$equals #$SymmetricBinaryPredicate) (#$isa #$equals #$DefaultMonotonicPredicate) (#$genlInverse #$equals #$equals) (#$arg1Isa #$equals #$Thing) (#$arg2Isa #$equals #$Thing) (#$comment #$equals "The predicate #$equals is the Cyc version of identity of predicate logic. (#$equals A B) means A and B denote the same thing.") ;;; #$equiv (#$isa #$equiv #$ELRelation) (#$isa #$equiv #$CommutativeRelation) (#$arg1Isa #$equiv #$CycFormula) (#$arg2Isa #$equiv #$CycFormula) (#$comment #$equiv "The logical connective #$equiv represents bi-directional implication. #$equiv takes two arguments, each of which must be an element of #$CycFormula. (#$equiv FORMULA-1 FORMULA-2) means that formula FORMULA-1 is true precisely when formula FORMULA-2 is true; in other words, FORMULA-1 is true if and only if FORMULA-2 is true. An EL formula that mentions #$equiv is translated during canonicalization into an equivalent (though less compact) formula that mentions #$implies and does not mention #$equiv (see the #$expansion gaf for #$equiv).") ;;; #$ethnicGroupsHere (#$isa #$ethnicGroupsHere #$BinaryPredicate) (#$isa #$ethnicGroupsHere #$IntangibleObjectPredicate) (#$arg1Isa #$ethnicGroupsHere #$GeopoliticalEntity) (#$arg2Isa #$ethnicGroupsHere #$EthnicGroupType) (#$comment #$ethnicGroupsHere "The ethnic groups that inhabit a geographical region.") ;;; #$ethnicity (#$isa #$ethnicity #$BinaryPredicate) (#$genlPreds #$ethnicity #$isa) (#$arg1Isa #$ethnicity #$Person) (#$arg2Isa #$ethnicity #$EthnicGroupType) (#$arg2Genl #$ethnicity #$Person) (#$comment #$ethnicity "(#$ethnicity PERSON GROUPTYPE) means #$Person PERSON belongs to the #$EthnicGroupType GROUPTYPE. E.g., (#$ethnicity #$JohnWilkesBooth #$CensusGroupOfCaucasians). One #$Person may belong to more than one #$EthnicGroupType.") ;;; #$evaluate (#$isa #$evaluate #$BinaryPredicate) (#$arg1Isa #$evaluate #$CycELVariable) (#$arg2Isa #$evaluate #$Thing) (#$comment #$evaluate "(#$evaluate VAR EXPRESSION) is satisfied by an HL module which evaluates EXPRESSION and binds VAR to the result. For example, (#$evaluate ?SUM (#$PlusFn 1 2)) would bind ?SUM to 3.") ;;; #$eventHonors (#$isa #$eventHonors #$IrreflexiveBinaryPredicate) (#$isa #$eventHonors #$Role) (#$isa #$eventHonors #$AsymmetricBinaryPredicate) (#$arg1Isa #$eventHonors #$SocialOccurrence) (#$arg2Isa #$eventHonors #$Agent) (#$comment #$eventHonors "(#$eventHonors OCCURRENCE AGENT) means that AGENT is honored or commemorated by OCCURRENCE. If AGENT is a living #$Person, AGENT is probably present at OCCURRENCE. This is the appropriate predicate for relating a #$Funeral to the deceased person for whom the #$Funeral is in honor.") ;;; #$eventOccursAt (#$isa #$eventOccursAt #$ActorSlot) (#$genlPreds #$eventOccursAt #$temporallyIntersects) (#$genlPreds #$eventOccursAt #$actors) (#$genlPreds #$eventOccursAt #$inRegion) (#$arg1Isa #$eventOccursAt #$Event) (#$arg2Isa #$eventOccursAt #$PartiallyTangible) (#$comment #$eventOccursAt "The predicate #$eventOccursAt relates a particular event to the instance of #$PartiallyTangible in which it occurs. (#$eventOccursAt EVENT PT) means that the spatial extent of EVENT is within PT. For example, (#$eventOccursAt #$LomaPrietaEarthquake #$SanFranciscoBayArea).") ;;; #$eventOccursNear (#$isa #$eventOccursNear #$ActorSlot) (#$arg1Isa #$eventOccursNear #$Event) (#$arg2Isa #$eventOccursNear #$PartiallyTangible) (#$comment #$eventOccursNear "The predicate #$eventOccursNear is used to give an approximate location for an event. (#$eventOccursNear EVENT LOC) means that EVENT occurs at a place #$near LOC. #$eventOccursNear is useful when the more exact #$eventOccursAt is unknown, hard to specify, or not worth reifying. For example, #$eventOccursNear is useful for describing the location of events in scenarios such as `Bob was cycling by the dam', `We played checkers near the TV', and `He is standing by the horse's hind legs'. See #$cyclistNotes for ideas on how to formalize this.") ;;; #$eventTypeTemporalLocality (#$isa #$eventTypeTemporalLocality #$IntervalBasedQuantitySlot) (#$arg1Isa #$eventTypeTemporalLocality #$ScriptType) (#$arg1Genl #$eventTypeTemporalLocality #$Event) (#$arg2Isa #$eventTypeTemporalLocality #$Time-Quantity) (#$comment #$eventTypeTemporalLocality "The time period over which the effects of this type of event may be felt. This could be infinite for certain events (such as killing a person), but for most events this is a much shorter period. E.g., some of the effects of swimming are being wet, being tired, being out of breath, etc. but those effect generally only persist for a period of minutes after the swimming ends.") ;;; #$evokes (#$isa #$evokes #$CotemporalPredicate) (#$isa #$evokes #$TernaryPredicate) (#$arg1Isa #$evokes #$Individual) (#$arg2Isa #$evokes #$FeelingAttributeType) (#$arg2Genl #$evokes #$FeelingAttribute) (#$arg3Isa #$evokes #$GenericAttribute) (#$comment #$evokes "(#$evokes OBJ EMOTYPE DEGREE) means that as a consequence of perceiving OBJ, a typical sane intelligent perceiving agent would experience a feeling of EMOTYPE with degree of intensity DEGREE. E.g., in some contexts, (#$evokes #$StatueOfLiberty #$Pride #$High).") ;;; #$exceptFor (#$isa #$exceptFor #$LogicalConnective) (#$isa #$exceptFor #$Relationship) (#$arg1Isa #$exceptFor #$ReifiableTerm) (#$arg2Isa #$exceptFor #$Assertion) (#$comment #$exceptFor "(#$exceptFor TERM ASSERTION) means that TERM is a thing, about which ASSERTION is not known to hold. #$exceptFor is a special case of #$exceptWhen (q.v.), applicable when ASSERTION has only one universally quantified variable. (#$exceptFor TERM ASSERTION) prevents TERM from binding to that variable, thereby blocking the conclusions about TERM that Cyc might otherwise draw from ASSERTION. In other words, if ASSERTION is an implication, then whatever proposition(s) -- call that Q -- that Cyc might have concluded about TERM from ASSERTION may or may not be true in Cyc, but (due to the exception) they would no longer be justified, even partially, by ASSERTION. Note that the exception TERM should be a particular binding for the rule, not a collection, all of whose members the rule does not apply to. Example: I have the rule (#$implies (#$isa ?X #$Cyclist) (#$loves ?X #$RichardNixon)). I could use #$exceptFor to state that this rule does not apply to some particular cyclist, e.g., #$Foxvog. But if I wanted to make an exception to this rule for all #$MalePersons, I would not use #$exceptFor, but #$exceptWhen.") ;;; #$exceptWhen (#$isa #$exceptWhen #$LogicalConnective) (#$isa #$exceptWhen #$Relationship) (#$arg1Isa #$exceptWhen #$CycFormula) (#$arg2Isa #$exceptWhen #$Assertion) (#$comment #$exceptWhen "(#$exceptWhen FORMULA ASSERTION) means that FORMULA gives a set of conditions under which ASSERTION is known not to hold (or, more precisely, conditions under which ASSERTION should not be relied upon as the justification for some other inferences). The universally quantified variables in ASSERTION's formula may be used in FORMULA to refer to the same objects. A common special case of #$exceptWhen is handled by #$exceptFor (q.v.)") ;;; #$exchangers (#$isa #$exchangers #$ActorSlot) (#$isa #$exchangers #$AsymmetricBinaryPredicate) (#$isa #$exchangers #$IrreflexiveBinaryPredicate) (#$genlPreds #$exchangers #$socialParticipants) (#$genlPreds #$exchangers #$performedBy) (#$genlPreds #$exchangers #$postActors) (#$genlPreds #$exchangers #$preActors) (#$arg1Isa #$exchangers #$ExchangeOfUserRights) (#$arg2Isa #$exchangers #$Agent) (#$comment #$exchangers "The predicate #$exchangers is used to identify the (typically, two) #$Agents involved in an instance of #$ExchangeOfUserRights. In such an event, each of the #$exchangers gives up possession of one thing and gains possession of another which was previously possessed by the other agent. (#$exchangers EXCH AGENT) means that AGENT is one of the parties having such a dual role in the #$ExchangeOfUserRights EXCH. Every instance of #$ExchangeOfUserRights has two sub-events which are instances of #$TransferringPossession (e.g., a dollar bill goes in one direction and some french fries and a few coins go in the other direction.) Each of the #$exchangers is both a #$toPossessor (in one of the two #$TransferringPossession sub-events of EXCH) and a #$fromPossessor (in the other sub-event).") ;;; #$exhibitors (#$isa #$exhibitors #$IrreflexiveBinaryPredicate) (#$isa #$exhibitors #$AsymmetricBinaryPredicate) (#$isa #$exhibitors #$ActorSlot) (#$genlPreds #$exhibitors #$socialParticipants) (#$arg1Isa #$exhibitors #$SocialGathering) (#$arg2Isa #$exhibitors #$Agent) (#$comment #$exhibitors "(#$exhibitors GATHERING AGENT) means that AGENT actively presents information, markets a product, displays merchandise or artwork to the attendees of GATHERING.") ;;; #$expansion (#$isa #$expansion #$BinaryPredicate) (#$arg1Isa #$expansion #$Relationship) (#$arg2Isa #$expansion #$CycSystemList) (#$comment #$expansion "The complex functions/relations can be explained in terms of more primitive functions. This slot contains such a primitive expansion.") ;;; #$expansionAxiom (#$isa #$expansionAxiom #$MetaKnowledgePredicate) (#$isa #$expansionAxiom #$BinaryPredicate) (#$arg1Isa #$expansionAxiom #$RuleMacroPredicate) (#$arg2Isa #$expansionAxiom #$Assertion) (#$comment #$expansionAxiom "(#$expansionAxiom PRED ASSERT) means that the assertion ASSERT is part of the expansion of PRED.") ;;; #$expects (#$isa #$expects #$PropositionalAttitudeSlot) (#$arg1Isa #$expects #$IntelligentAgent) (#$arg2Isa #$expects #$CycFormula) (#$comment #$expects "(#$expects AGT PROP) means that the agent AGT believes the proposition PROP (represented by a #$CycFormula) will be true sometime in the future. A use of this predicate is to state rules such as: when someone confirms that they will be participating in a social event, the host(ess) #$expects that they will participate.") ;;; #$exports (#$isa #$exports #$ProcessPredicate) (#$isa #$exports #$BinaryPredicate) (#$arg1Isa #$exports #$GeopoliticalEntity) (#$arg2Isa #$exports #$ProductType) (#$arg2Genl #$exports #$PartiallyTangible) (#$comment #$exports "(exports REGION THING) means that the region REGION has substantial regular exports of the commodity THING.") ;;; #$externalParts (#$isa #$externalParts #$PhysicalPartPredicate) (#$isa #$externalParts #$TransitiveBinaryPredicate) (#$isa #$externalParts #$AntiSymmetricBinaryPredicate) (#$isa #$externalParts #$CotemporalObjectsSlot) (#$genlPreds #$externalParts #$physicalParts) (#$genlPreds #$externalParts #$cotemporal) (#$arg1Isa #$externalParts #$PartiallyTangible) (#$arg2Isa #$externalParts #$PartiallyTangible) (#$comment #$externalParts "(#$externalParts OBJ PART) means that OBJ has PART as one of its external #$physicalParts.") ;;; #$eyeColor (#$isa #$eyeColor #$TangibleObjectPredicate) (#$isa #$eyeColor #$PhysicalAttributeDescriptionSlot) (#$arg1Isa #$eyeColor #$Animal) (#$arg2Isa #$eyeColor #$Color) (#$comment #$eyeColor "(#$eyeColor ANIMAL COLOR) means that the #$Animal ANIMAL has eyes whose #$Color is COLOR (more precisely, this means that their irises appear to have that color, in sunlight). E.g., (#$eyeColor AmyIrving #$PurpleColor).") ;;; #$facesDirection (#$isa #$facesDirection #$BinaryPredicate) (#$isa #$facesDirection #$SpatialPredicate) (#$arg1Isa #$facesDirection #$PartiallyTangible) (#$arg2Isa #$facesDirection #$UnitVectorInterval) (#$comment #$facesDirection "(#$facesDirection OBJ DIR) means that the intrinsic forward axis of OBJ (i.e., the vector normal to its intrinsic front side) points in the direction DIR. Note that an object only has an intrinsic forward axis if it has some intrinsic front side by virtue of its design or function. For example, trains, cars, and bullets have intrinsic front faces by virtue of the direction in which they are intended to travel. Other objects, such as refrigerators, bookshelves against walls, and televisions, have front faces by virtue of how people usually view the object. Spheres, being symmetric, do not have an intrinsic forward axis.") ;;; #$facesObject (#$isa #$facesObject #$TernaryPredicate) (#$arg1Isa #$facesObject #$PartiallyTangible) (#$arg2Isa #$facesObject #$IntrinsicAxisOfObject) (#$arg3Isa #$facesObject #$PartiallyTangible) (#$comment #$facesObject "The Cyc predicate #$facesObject is used to represent the orientation of one object to another. (#$facesObject OBJ1 AXIS1 OBJ2) means that an intrinsic axis projected through OBJ1 (i.e., AXIS1) spatially intersects with the second object, OBJ2. See also #$IntrinsicAxisOfObject, #$AxisFn.") ;;; #$failureForAgents (#$isa #$failureForAgents #$ActorSlot) (#$genlPreds #$failureForAgents #$performedBy) (#$arg1Isa #$failureForAgents #$PurposefulAction) (#$arg2Isa #$failureForAgents #$Agent) (#$comment #$failureForAgents "The predicate #$failureForAgents is used to indicate that a particular agent fails to achieve (at least one of) its goals in a particular action. (#$failureForAgents ENDEAVOR AGT) means that the #$Agent AGT had some purpose in performing ENDEAVOR that was not realized. See also #$purposeInEvent.") ;;; #$fanOutArg (#$isa #$fanOutArg #$BinaryPredicate) (#$arg1Isa #$fanOutArg #$TransitiveBinaryPredicate) (#$arg2Isa #$fanOutArg #$PositiveInteger) (#$comment #$fanOutArg "(#$fanOutArg ?PRED ?N) means that transitively-related assertions using ?PRED usually ''fan out'' in the direction of argument position ?N. For example, (#$fanOutArg #$geographicalSubRegions 2). This means there are more non-subsumed arg2s for a given arg1 to #$geographicalSubRegions than there would be non-subsumed arg1s for a given arg2.") ;;; #$fastenedTo (#$not (#$isa #$fastenedTo #$IrreflexiveBinaryPredicate)) (#$not (#$isa #$fastenedTo #$ReflexiveBinaryPredicate)) (#$not (#$isa #$fastenedTo #$TransitiveBinaryPredicate)) (#$isa #$fastenedTo #$SymmetricBinaryPredicate) (#$isa #$fastenedTo #$ConnectionPredicate) (#$isa #$fastenedTo #$SpatialPredicate) (#$genlPreds #$fastenedTo #$connectedTo-Rigidly) (#$genlInverse #$fastenedTo #$fastenedTo) (#$arg1Isa #$fastenedTo #$SolidTangibleThing) (#$arg2Isa #$fastenedTo #$SolidTangibleThing) (#$comment #$fastenedTo "(#$fastenedTo OBJ1 OBJ2) means that there is an assembly consisting of OBJ1, OBJ2, and one or more fasteners configured so that OBJ1 and OBJ2 are rigidly connected. Many types of fastener are covered by #$fastenedTo; e.g., screws, nails, rivets, nuts and bolts. The fastener penetrates all the way through OBJ1 and may or may not go all the way through OBJ2. Examples: a utility shelf screwed into the wall; paper notices stapled to a bulletin board; shingles nailed to the roof of a house.") ;;; #$father (#$isa #$father #$CotemporalObjectsSlot) (#$isa #$father #$AntiTransitiveBinaryPredicate) (#$isa #$father #$AsymmetricBinaryPredicate) (#$isa #$father #$FamilyRelationSlot) (#$isa #$father #$IrreflexiveBinaryPredicate) (#$genlPreds #$father #$cotemporal) (#$arg1Isa #$father #$Animal) (#$arg2Isa #$father #$MaleAnimal) (#$comment #$father "(#$father OFFSPRING MALE) means that #$MaleAnimal MALE is the male biological parent of #$Animal OFFSPRING.") (#$comment #$father "(#$father CHILD FATHER) means FATHER is one of the persons who fulfill the role of father for CHILD. This may or may not include CHILD's biological father, and might include CHILD's step father(s) or foster father(s).") ;;; #$faxNumberText (#$isa #$faxNumberText #$BinaryPredicate) (#$arg1Isa #$faxNumberText #$ContactLocation) (#$arg2Isa #$faxNumberText #$PhoneNumber) (#$comment #$faxNumberText "The predicate #$faxNumberText relates a particular location to the fax number at that location. (#$faxNumberText LOC NUM) means that NUM is a string denoting (one of) the fax number(s) of the #$ContactLocation LOC.") ;;; #$feelsEmotion (#$isa #$feelsEmotion #$CotemporalPredicate) (#$isa #$feelsEmotion #$TernaryPredicate) (#$arg1Isa #$feelsEmotion #$IntelligentAgent) (#$arg2Isa #$feelsEmotion #$FeelingAttributeType) (#$arg2Genl #$feelsEmotion #$FeelingAttribute) (#$arg3Isa #$feelsEmotion #$GenericAttribute) (#$comment #$feelsEmotion "(#$feelsEmotion AGT EMOTYPE DEGREE) means that the #$IntelligentAgent AGT feels a feeling of the type EMOTYPE with the intensity DEGREE. For example, (#$feelsEmotion #$Lenat #$Pride #$High). As you might imagine, such statements are generally embedded in a context, or within some other statement (such as #$holdsIn some small time interval). See also #$feelsTowardsEvent, #$feelsTowardsObject. Note: the first argument can be a non-human intelligent agent, such as a dog or a company, because we often ascribe feelings and emotions to them, and they often behave consistently with having such feelings and emotions.") (#$overlappingExternalConcept #$feelsEmotion #$SENSUS-Information1997 "REACTION") ;;; #$feelsResponseOnBodyRegion (#$isa #$feelsResponseOnBodyRegion #$QuaternaryPredicate) (#$isa #$feelsResponseOnBodyRegion #$FunctionalPredicate) (#$arg1Isa #$feelsResponseOnBodyRegion #$PerceptualAgent) (#$arg2Isa #$feelsResponseOnBodyRegion #$ExistingObjectType) (#$arg2Genl #$feelsResponseOnBodyRegion #$AnimalBodyRegion) (#$arg3Isa #$feelsResponseOnBodyRegion #$SensoryReactionType) (#$arg4Isa #$feelsResponseOnBodyRegion #$GenericAttribute) (#$comment #$feelsResponseOnBodyRegion "The Cyc predicate #$feelsResponseOnBodyRegion is used to represent localized somatic feelings of a perceptive being. (#$feelsResponseOnBodyRegion AGT BODYPARTTYPE SENS DEGREE) means that the #$PerceptualAgent AGT feels on its body, in the area specified by BODYPARTTYPE, the sensory reaction SENS with an intensity of DEGREE. For example, Cyc's knowledge base contains an assertion that the very same part of one's body doesn't feel both hot and cold at the same time. #$feelsResponseOnBodyRegion can also be used to state symptoms, e.g., when you're feverish, your head feels hot. See also #$SensoryReactionType.") ;;; #$feelsSensation (#$isa #$feelsSensation #$TernaryPredicate) (#$isa #$feelsSensation #$FunctionalPredicate) (#$arg1Isa #$feelsSensation #$BiologicalLivingObject) (#$arg2Isa #$feelsSensation #$SensoryReactionType) (#$arg2Genl #$feelsSensation #$SensoryAttribute) (#$arg3Isa #$feelsSensation #$GenericAttribute) (#$comment #$feelsSensation "(#$feelsSensation BLO SENSTYPE DEGREE) means that the #$BiologicalLivingObject BLO feels a sensation of type SENSTYPE with the intensity DEGREE. #$feelsSensation may be used to describe an organism's feeling during a particular time period or activity (see #$holdsIn); for example, we might say of a particular person who is doing yoga: (#$holdsIn `TodaysYoga' (#$feelsSensation Prakriti #$LevelOfRelaxationFeeling #$VeryHigh). Note that the first argument of #$feelsSensation could also be filled by a part of an organism, e.g., `John F. Kennedy's head'; however, by using the more specialized predicate #$feelsResponseOnBodyRegion (q.v.), we can express localized feelings without reifying each such region.") ;;; #$feelsTowardsEvent (#$isa #$feelsTowardsEvent #$QuaternaryPredicate) (#$arg1Isa #$feelsTowardsEvent #$Person) (#$arg1Isa #$feelsTowardsEvent #$IntelligentAgent) (#$arg2Isa #$feelsTowardsEvent #$Event) (#$arg3Isa #$feelsTowardsEvent #$FeelingAttributeType) (#$arg3Genl #$feelsTowardsEvent #$FeelingAttribute) (#$arg4Isa #$feelsTowardsEvent #$GenericAttribute) (#$comment #$feelsTowardsEvent "(#$feelsTowardsEvent AGT EVT EMOTYPE DEGREE) means that the #$IntelligentAgent AGT feels a feeling of the #$FeelingAttributeType EMOTYPE towards the #$Event EVT, with intensity DEGREE. Note: the first argument can be a non-human intelligent agent, such as a dog or a company, because we often ascribe feelings and emotions to them, and they often behave consistently with having such feelings and emotions. ") ;;; #$feelsTowardsObject (#$isa #$feelsTowardsObject #$QuaternaryPredicate) (#$arg1Isa #$feelsTowardsObject #$Person) (#$arg1Isa #$feelsTowardsObject #$IntelligentAgent) (#$arg2Isa #$feelsTowardsObject #$Individual) (#$arg3Isa #$feelsTowardsObject #$FeelingAttributeType) (#$arg3Genl #$feelsTowardsObject #$FeelingAttribute) (#$arg4Isa #$feelsTowardsObject #$GenericAttribute) (#$comment #$feelsTowardsObject "(#$feelsTowardsObject AGT OBJ EMOTYPE DEGREE) means that the #$IntelligentAgent AGT feels a feeling of the #$FeelingAttributeType EMOTYPE towards the #$Individual OBJ, with intensity DEGREE. Note: the first argument can be a non-human intelligent agent, such as a dog or a company, because we often ascribe feelings and emotions to them, and they often behave consistently with having such feelings and emotions.") ;;; #$femaleParentActor (#$isa #$femaleParentActor #$IrreflexiveBinaryPredicate) (#$isa #$femaleParentActor #$AntiTransitiveBinaryPredicate) (#$isa #$femaleParentActor #$AsymmetricBinaryPredicate) (#$isa #$femaleParentActor #$ActorSlot) (#$isa #$femaleParentActor #$FunctionalSlot) (#$genlPreds #$femaleParentActor #$parentActors) (#$arg1Isa #$femaleParentActor #$BiologicalReproductionEvent) (#$arg2Isa #$femaleParentActor #$BiologicalLivingObject) (#$comment #$femaleParentActor "(#$femaleParentActor ?EVENT ?ORGANISM) means that ?ORGANISM is the female parent in the #$SexualReproductionEvent ?EVENT.") ;;; #$fieldsOfActivity (#$isa #$fieldsOfActivity #$BinaryPredicate) (#$genlPreds #$fieldsOfActivity #$fieldsOfCompetence) (#$arg1Isa #$fieldsOfActivity #$Person) (#$arg2Isa #$fieldsOfActivity #$FieldOfStudy) (#$comment #$fieldsOfActivity "(#$fieldsOfActivity X FLD) means the #$Person X was or is active in the #$FieldOfStudy FLD, and usually is making, has made, or intends to make some contribution to FLD. E.g., (#$fieldsOfActivity #$Thales #$MilesianSchool) and, to take a more recent example, (#$fieldsOfActivity #$Lenat #$ArtificialIntelligence).") ;;; #$fieldsOfCompetence (#$isa #$fieldsOfCompetence #$BinaryPredicate) (#$arg1Isa #$fieldsOfCompetence #$Person) (#$arg2Isa #$fieldsOfCompetence #$FieldOfStudy) (#$comment #$fieldsOfCompetence "(#$fieldsOfCompetence Z FLD) means the #$Person Z has actual competence and knowledgeability in the #$FieldOfStudy FLD, or else at least is recognized by peers and colleagues in the same field as being competent in that field. E.g., (#$fieldsOfCompetence #$Nichols #$PhilosophyAncient)") ;;; #$fieldsOfFormalEducation (#$isa #$fieldsOfFormalEducation #$BinaryPredicate) (#$genlPreds #$fieldsOfFormalEducation #$fieldsOfCompetence) (#$arg1Isa #$fieldsOfFormalEducation #$Person) (#$arg2Isa #$fieldsOfFormalEducation #$FieldOfStudy) (#$comment #$fieldsOfFormalEducation "(#$fieldsOfFormalEducation Z FLD) means that #$Person Z has had formal academic or tutorial education in the #$FieldOfStudy FLD. E.g., (#$fieldsOfFormalEducation #$Colvin #$Linguistics). This is a good example of a predicate whose precise meaning, and associated heuristic rules, vary quite a bit from context to context, such as from culture to culture, from century to century, etc.") ;;; #$firstName (#$isa #$firstName #$BinaryPredicate) (#$isa #$firstName #$IntangibleObjectPredicate) (#$genlPreds #$firstName #$nameOfAgent) (#$arg1Isa #$firstName #$Person) (#$arg2Isa #$firstName #$HumanGivenNameString) (#$comment #$firstName "(#$firstName X STRNG) means that #$Person X is known by the #$HumanGivenNameString STRNG as his or her first name. E.g., (#$firstName #$Lenat ``Douglas''). A person rarely has more than one first name, though they may have many nicknames which acquaintences use almost interchangably with the person's first and/or last names.") ;;; #$firstSubEvents (#$isa #$firstSubEvents #$TransitiveBinaryPredicate) (#$isa #$firstSubEvents #$SubProcessSlot) (#$genlPreds #$firstSubEvents #$temporallyStartedBy) (#$genlPreds #$firstSubEvents #$subEvents) (#$arg1Isa #$firstSubEvents #$Event) (#$arg2Isa #$firstSubEvents #$Event) (#$comment #$firstSubEvents "(#$firstSubEvents ?X ?Y) implies (#$subEvents ?X ?Y) and (#$temporallyStartedBy ?X ?Y). For example, if one is #$RelievingPain by taking a pill, then the #$firstSubEvents in that event is an #$Ingesting event. See also #$lastSubEvents.") ;;; #$fiscallyCapableOf (#$isa #$fiscallyCapableOf #$TernaryPredicate) (#$arg1Isa #$fiscallyCapableOf #$IntelligentAgent) (#$arg2Isa #$fiscallyCapableOf #$Collection) (#$arg2Genl #$fiscallyCapableOf #$Situation) (#$arg3Isa #$fiscallyCapableOf #$Role) (#$comment #$fiscallyCapableOf "The predicate #$fiscallyCapableOf indicates that an agent has the economic prerequisites needed for taking a certain role in a certain type of situation or event. (#$fiscallyCapableOf AGT SIT-TYPE ROLE) means that a particular #$Agent AGT has the financial resources for acting in this ROLE in normal instances of SIT-TYPE. For example, we could say that Mary is #$fiscallyCapableOf being the #$buyer in a #$Buying of a Humvee (i.e., (#$BuyingFn Humvee)). However, #$fiscallyCapableOf is noncommittal as to whether Mary does or will in fact buy a Humvee.") ;;; #$fitsIn (#$isa #$fitsIn #$BinaryPredicate) (#$arg1Isa #$fitsIn #$PartiallyTangible) (#$arg2Isa #$fitsIn #$AbstractShape) (#$comment #$fitsIn "The predicate #$fitsIn is used to give an approximation of the external size and shape of particular tangible objects, by relating an object to an abstract region of space described as a geometric shape with definite dimensions. (#$fitsIn OBJ SHAPE) gives an upper bound for the size of the object OBJ, by stating what sized shape OBJ will fit inside. #$fitsIn uses the elements of #$ShapeFunction (q.v.) for reference, especially the basic shapes generated by #$RectangularSolidFn, #$CylinderFn, and #$SphereFn. (Note: actual instances of AbstractPhysicalShape are NOT used for assertions made with #$fitsIn.) Examples: (#$fitsIn #$Pittman (#$RectangularSolidFn (#$Meter 2) (#$Meter 0.35) (#$Meter 0.25))) and (#$fitsIn HopeDiamond (#$CylinderFn (#$Centimeter 10) (#$Centimeter 10))). When #$fitsIn is used in a rule to represent a class of objects with variable sizes, the #$ShapeFunction used should refer to the largest size that such objects normally have. For example, by default, any sandwich SW (#$fitsIn SW (#$RectangularSolidFn (#$Inch 12) (#$Inch 12) (#$Inch 6))).") ;;; #$flammabilityOfObject (#$isa #$flammabilityOfObject #$TangibleObjectPredicate) (#$isa #$flammabilityOfObject #$IntervalBasedQuantitySlot) (#$isa #$flammabilityOfObject #$PhysicalAttributeDescriptionSlot) (#$arg1Isa #$flammabilityOfObject #$PartiallyTangible) (#$arg2Isa #$flammabilityOfObject #$Flammability) (#$comment #$flammabilityOfObject "(#$flammabilityOfObject SUBST DEGREE) means that the tangible SUBST has this DEGREE of #$Flammability. A higher value of DEGREE describes objects that catch fire and burn more quickly and easily than those with a lower value.") ;;; #$fluidPressure (#$isa #$fluidPressure #$IntervalBasedQuantitySlot) (#$isa #$fluidPressure #$TangibleSubstancePredicate) (#$arg1Isa #$fluidPressure #$FluidTangibleThing) (#$arg2Isa #$fluidPressure #$Pressure) (#$comment #$fluidPressure "(#$fluidPressure FLUID PRESS) means that the #$FluidTangibleThing FLUID exerts the #$Pressure PRESS at its surface.") ;;; #$followingIntervalType (#$isa #$followingIntervalType #$TemporalRelation) (#$not (#$isa #$followingIntervalType #$TransitiveBinaryPredicate)) (#$not (#$isa #$followingIntervalType #$SymmetricBinaryPredicate)) (#$not (#$isa #$followingIntervalType #$AntiSymmetricBinaryPredicate)) (#$not (#$isa #$followingIntervalType #$AsymmetricBinaryPredicate)) (#$not (#$isa #$followingIntervalType #$ReflexiveBinaryPredicate)) (#$not (#$isa #$followingIntervalType #$IrreflexiveBinaryPredicate)) (#$arg1Isa #$followingIntervalType #$TemporalObjectType) (#$arg2Isa #$followingIntervalType #$TemporalObjectType) (#$comment #$followingIntervalType "(#$followingIntervalType ?X ?Y) indicates that every instance of ?X is followed by some instance of ?Y, and every instance of ?Y is preceded by some instance of ?X. The instance of ?Y is #$contiguousAfter the instance of ?X. For example, (#$followingIntervalType #$Saturday #$Sunday). Every Saturday is followed by a Sunday, and every Sunday is preceded by a Saturday; the Sunday is #$contiguousAfter the Saturday.") ;;; #$followingValue (#$isa #$followingValue #$IrreflexiveBinaryPredicate) (#$isa #$followingValue #$ExtensionalRepresentationPredicate) (#$isa #$followingValue #$AsymmetricBinaryPredicate) (#$isa #$followingValue #$TransitiveBinaryPredicate) (#$genlInverse #$followingValue #$greaterThan) (#$arg1Isa #$followingValue #$ScalarInterval) (#$arg2Isa #$followingValue #$ScalarInterval) (#$argsIsa #$followingValue #$ScalarInterval) (#$comment #$followingValue "The Cyc predicate #$followingValue is used to represent an ordering of generic attributes. (#$followingValue VAL1 VAL2) means that VAL2 is a greater value than VAL1 on a scale that they share. (#$followingValue VAL1 VAL2) implies (#$greaterThan VAL2 VAL1). Typically, one uses #$followingValue when the values VAL1 and VAL2 are elements of #$GenericAttribute, and they are not grounded in numerically quantifiable units of measure (see #$NoteAboutGivingGenericValueFunctionsNumericValues). If VAL1 and VAL2 do have numerical grounding, a #$followingValue formula is unnecessary since #$numericallyEqual, #$greaterThanOrEqualTo, and #$greaterThan, are automatically computable using arithmetic relations holding between the minimum and maximum of val1 and val2. (See #$minQuantValue, #$maxQuantValue.) For example, one must use #$followingValue to state that (#$HighAmountFn #$Glamor) is more glamorous than (#$LowAmountFn #$Glamor). On the other hand, it is unnecessary to assert a #$followingValue relation between (#$MilesPerHour 5) and (#$MilesPerHour 25 60) since #$greaterThan is arithmetically determinable. See also #$GenericAttribute, #$GenericValueFunction.") ;;; #$foodSourceFor (#$isa #$foodSourceFor #$BinaryPredicate) (#$arg1Isa #$foodSourceFor #$Organism-Whole) (#$arg2Isa #$foodSourceFor #$TemporalStuffType) (#$arg2Genl #$foodSourceFor #$PartiallyTangible) (#$comment #$foodSourceFor "The predicate #$foodSourceFor is used to relate a particular organism to the kinds of things it usually eats. (#$foodSourceFor ORG OBJTYPE) means ORG is an organism that typically eats some instances of OBJTYPE for food. Note that OBJTYPE refers to a type of food source, not a particular object that ORG eats. For example, (#$foodSourceFor #$BillJ #$Popcorn) means that #$Popcorn is a #$foodSourceFor Bill, i.e., Bill often eats (instances of) popcorn.") ;;; #$forAll (#$isa #$forAll #$Quantifier) (#$isa #$forAll #$Relationship) (#$arg1Isa #$forAll #$CycELVariable) (#$arg2Isa #$forAll #$CycFormula) (#$comment #$forAll "The predicate #$forAll is Cyc's version of the universal quantifier of predicate calculus (i.e., the operator symbolized in one common notation by an upside-down `A'). As its two arguments, #$forAll takes a variable (which is an element of #$CycELVariable) and an element of #$CycFormula, respectively. (#$forAll VAR FORM) means that FORM is true whenever all the occurrences of the variable VAR in the formula FORM are replaced by any object in the Cyc universe. For example, to say that every person is a mammal, we could assert: (#$forAll ?X (#$implies (#$isa ?X #$Person) (#$isa ?X #$Mammal))). In addition, CycL follows a convention that allows #$forAll to be omitted; that is, when no explicit quantifier is used, seemingly unbound variables inside formulas are assumed to be universally quantified. With that convention, the sample assertion could be written more compactly as: (#$implies (#$isa ?X #$Person) (#$isa ?X #$Mammal)). [Developer-level footnote: There are many `flavors' of quantification `on the market' these days; here is how the Cyc system currently handles axioms that involve #$forAll: When processing an FI-ASK about whether an assertion of the form (#$forAll VAR FORM) is true or not, Cyc determines extensionally whether or not any known VAR (anything in the knowledge base) could make FORM false. When processing an FI-PROVE about whether an assertion of the form (#$forAll VAR FORM) is true or not, Cyc tries to construct an intensional proof (at least at a default-true level) that FORM must be true regardless of what VAR is ever inserted therein. When processing an FI-ASSERT in which a user or program tells Cyc that an assertion of the form (#$forAll VAR FORM) is true, Cyc records it intensionally so that it can later serve as part of an intensional proof, when some future FI-PROVE request is processed.]") ;;; #$forceActingOnObject (#$isa #$forceActingOnObject #$IntervalBasedQuantitySlot) (#$isa #$forceActingOnObject #$TangibleObjectPredicate) (#$arg1Isa #$forceActingOnObject #$PartiallyTangible) (#$arg2Isa #$forceActingOnObject #$VectorInterval) (#$arg2Isa #$forceActingOnObject #$PhysicalAttribute) (#$comment #$forceActingOnObject "#$forceActingOnObject is a predicate relating an instance of #$PartiallyTangible to any force which changes its direction of travel or the speed at which it is traveling.") ;;; #$forceCapacity (#$isa #$forceCapacity #$IntervalBasedQuantitySlot) (#$arg1Isa #$forceCapacity #$BiologicalLivingObject) (#$arg2Isa #$forceCapacity #$Strength) (#$comment #$forceCapacity "The slot describing the capability of an animal to exert force.") ;;; #$formedByConfluenceOf (#$isa #$formedByConfluenceOf #$AntiTransitiveBinaryPredicate) (#$isa #$formedByConfluenceOf #$AsymmetricBinaryPredicate) (#$arg1Isa #$formedByConfluenceOf #$River) (#$arg2Isa #$formedByConfluenceOf #$River) (#$comment #$formedByConfluenceOf "(formedByConfluenceOf WATER1 WATER2) means that WATER1 is formed, or increased in volume, by the confuence of the rivers including RIVER2 which merge to form RIVER1.") ;;; #$formsBorderBetween (#$isa #$formsBorderBetween #$SpatialPredicate) (#$isa #$formsBorderBetween #$TernaryPredicate) (#$arg1Isa #$formsBorderBetween #$SpatialThing) (#$arg2Isa #$formsBorderBetween #$SpatialThing) (#$arg3Isa #$formsBorderBetween #$SpatialThing) (#$comment #$formsBorderBetween "(#$formsBorderBetween BORDER REG1 REG2) means that BORDER comprises at least part of the border between REG1 and REG2. BORDER may be a surface separating two regions of space, or a curve separating two regions of a surface. The arguments REG1 and REG2 may be physical objects, geographical regions, or abstract entities. Note that BORDER need not comprise the entire border between REG1 and REG2. By contrast, #$BorderBetweenFn returns the entire border between the regions that serve as arguments.") ;;; #$fourWayJunctionInSystem (#$isa #$fourWayJunctionInSystem #$AsymmetricBinaryPredicate) (#$genlPreds #$fourWayJunctionInSystem #$junctionInSystem) (#$comment #$fourWayJunctionInSystem "(#$fourWayJunctionInSystem JUNCT SYS) means that JUNCT is a 4-way junction in the specified #$PathSystem SYS. (See also #$FourWayJunctionOfPaths for the general case.) Formally, a 4-way junction in SYS is any point (actually, a node) X in SYS such that either there are exactly 4 links and no loops in SYS that X is on, or there are exactly 2 loops and no links in SYS that X is on, or there are exactly 2 links and 1 loop in SYS that X is on. See #$junctionInSystem.") ;;; #$fragilityOfObject (#$isa #$fragilityOfObject #$TangibleObjectPredicate) (#$isa #$fragilityOfObject #$IntervalBasedQuantitySlot) (#$arg1Isa #$fragilityOfObject #$PartiallyTangible) (#$arg2Isa #$fragilityOfObject #$Fragility) (#$comment #$fragilityOfObject "(#$fragilityOfObject OBJ DEGREE) means that the tangible object OBJ has this DEGREE of #$Fragility. The higher the fragility, the more easily the object can be broken.") ;;; #$freezingPoint (#$isa #$freezingPoint #$IntervalBasedQuantitySlot) (#$isa #$freezingPoint #$TangibleSubstancePredicate) (#$arg1Isa #$freezingPoint #$PartiallyTangible) (#$arg2Isa #$freezingPoint #$Temperature) (#$comment #$freezingPoint "(#$freezingPoint STUFF TEMP) means that TEMP is the temperature at which the substance STUFF changes from having the attribute #$LiquidStateOfMatter to #$SolidStateOfMatter (when sufficient energy is output to lower STUFF's temperature through this point). Note that the freezing point of most substances is context-dependent (e.g., based on altitude and other factors.)") ;;; #$frequencyOfActionType (#$isa #$frequencyOfActionType #$QuaternaryPredicate) (#$isa #$frequencyOfActionType #$FunctionalPredicate) (#$isa #$frequencyOfActionType #$TypePredicate) (#$arg1Isa #$frequencyOfActionType #$Collection) (#$arg1Genl #$frequencyOfActionType #$Situation) (#$arg2Isa #$frequencyOfActionType #$Collection) (#$arg3Isa #$frequencyOfActionType #$ActorSlot) (#$arg4Isa #$frequencyOfActionType #$Frequency) (#$comment #$frequencyOfActionType "(#$frequencyOfActionType ?X ?Y ?R ?F) indicates that instances of ?Y play the role ?R in a number of instances of ?X, and they occur with the frequency ?F. One axiom in Cyc that uses this predicate expresses the rule of thumb that each military typically wages war about once a generation: (#$frequencyOfActionType #$WagingWar #$MilitaryOrganization #$performedBy #$OnceAGeneration). Another use of it is to express the fact that animals are virtually always breathing: (#$frequencyOfActionType #$Breathing #$Vertebrate #$bodilyDoer #$Continuously). Even more interesting examples of this predicate express the the rules of thumb that in a modern Western personal... context a person engages in a toothbrushing event about once a day, while as the recipient of professional service that happens 0.5 - 4 times per year, while as the provider of such a service that happens 4 - 20 times per day. Those three axioms would be written -- in the appropriate contexts of course -- (#$frequencyOfActionType #$TeethCleaning #$Person #$performedBy (#$TimesPerDay 1)) and (#$frequencyOfActionType #$TeethCleaning #$Person #$recipientOfService (#$TimesPerYear 0.5 4)) and (#$frequencyOfActionType #$TeethCleaning #$Person #$providerOfService (#$TimesPerDay 4 20)). Two additional notes are in order about this predicate: Note that ?X must be a set of #$Situations [there is an argument constraint on this predicate that enforces this, namely (#$arg1Genl #$frequencyOfActionType #$Situation)],. Note that this predicate is functional in its fourth argument position. That is, given a legal set of values for ?X, ?Y, and ?R, there is one and only one meaningful value for the frequency ?F [this is specified by the Cyc axiom (#$functionalInTheNthArg #$frequencyOfActionType 4)].") ;;; #$frequencyOfSignal (#$isa #$frequencyOfSignal #$BinaryPredicate) (#$arg1Isa #$frequencyOfSignal #$WavePropagation) (#$arg2Isa #$frequencyOfSignal #$Frequency) (#$comment #$frequencyOfSignal "(#$frequencyOfSignal WAVE FREQ) means that the #$WavePropagation event WAVE consists of waves that occur at intervals of FREQ. FREQ is a measure of #$Frequency generally expressed as cycles per unit of time; frequency of electromagnetic radiation is standardly measured in #$Hertz.") ;;; #$friends (#$isa #$friends #$CotemporalObjectsSlot) (#$isa #$friends #$InterPersonalRelationSlot) (#$isa #$friends #$SymmetricBinaryPredicate) (#$isa #$friends #$IrreflexiveBinaryPredicate) (#$not (#$isa #$friends #$TransitiveBinaryPredicate)) (#$genlPreds #$friends #$likesAsFriend) (#$genlPreds #$friends #$cotemporal) (#$genlInverse #$friends #$friends) (#$arg1Isa #$friends #$Animal) (#$arg2Isa #$friends #$Animal) (#$comment #$friends "(#$friends X Y) means X and Y are friends; typically they have a close relationship of reciprocal care, concern, respect, enjoyment, and mutual regard based on emotional (and/or ideological and intellectual) compatibility, shared interests, etc. Note: In the cases of assertions of two non-human animals being friends, there may be some anthropomorphism going on.") ;;; #$fromLocation (#$isa #$fromLocation #$ActorSlot) (#$isa #$fromLocation #$AsymmetricBinaryPredicate) (#$isa #$fromLocation #$IrreflexiveBinaryPredicate) (#$genlPreds #$fromLocation (#$MeaningInSystemFn #$SENSUS-Information1997 "SOURCE-DESTINATION")) (#$genlPreds #$fromLocation #$preActors) (#$arg1Isa #$fromLocation #$Translocation) (#$arg2Isa #$fromLocation #$PartiallyTangible) (#$comment #$fromLocation "The predicate #$fromLocation is used to indicate the starting point of a particular movement. (#$fromLocation MOVE LOC) means that LOC is where the #$objectMoving in the #$Movement-TranslationEvent MOVE is found at the beginning of MOVE and is where it begins this motion. The #$objectMoving may or may not be #$Stationary at LOC. If MOVE is a single-pathway translation (see #$Translation-SinglePath), then every #$objectMoving is found at LOC when MOVE starts. If MOVE has multiple movers and multiple pathways (see #$Translation-MultiPath), then at least some of the #$objectMoving(s) can be found at LOC at the start of MOVE. If MOVE is a flow (including rivers flowing, winds blowing, tornado, typhoon, clouds moving and even air filling your lungs when you take breath, see #$Translation-Flow), then at least some portion of the fluid #$objectMoving can be found at LOC at the start of MOVE. See also #$pathway-Complete, #$pathConnects.") (#$synonymousExternalConcept #$fromLocation #$SENSUS-Information1997 "SOURCE") ;;; #$fromOrientation (#$isa #$fromOrientation #$Role) (#$isa #$fromOrientation #$BinaryPredicate) (#$arg1Isa #$fromOrientation #$Movement-Rotation) (#$arg2Isa #$fromOrientation #$OrientationAttribute) (#$comment #$fromOrientation "This predicate indicates, for the particular rotational motion ROT, the orientation that the #$objectMoving in that event has at the beginning of that motion. (#$fromOrientation ROT ORIENT) means that when ROT begins, the object that moves in ROT has the position ORIENT, with respect to the current frame of reference. For example, the object may have a #$HorizontalOrientation, #$VerticalOrientation, #$RightSideUp orientation, etc. See also #$toOrientation, #$OrientationAttribute.") ;;; #$fromPossessor (#$isa #$fromPossessor #$ActorSlot) (#$isa #$fromPossessor #$AsymmetricBinaryPredicate) (#$isa #$fromPossessor #$IrreflexiveBinaryPredicate) (#$genlPreds #$fromPossessor #$preActors) (#$arg1Isa #$fromPossessor #$LosingUserRights) (#$arg2Isa #$fromPossessor #$Agent) (#$comment #$fromPossessor "This predicate identifies an #$Agent who loses some right to use an object. (#$fromPossessor LOSS AGENT) means that AGENT enjoys some #$UserRightsAttribute over the #$objectOfPossessionTransfer at the start of the #$LosingUserRights event LOSS, but no longer has that particular #$UserRightsAttribute after the LOSS ends.") ;;; #$fromState (#$isa #$fromState #$BinaryPredicate) (#$arg1Isa #$fromState #$ChangingDeviceState) (#$arg2Isa #$fromState #$DeviceState) (#$comment #$fromState "This predicate is used in connection with #$ChangingDeviceState, to identify the #$DeviceState that a device is in before the change. (#$fromState EVENT DEVICE-STATE) means that immediately prior to EVENT (which is the device state-changing action), the device that is changed in EVENT has the state DEVICE-STATE (and during the EVENT the device changes from that to another state). For example, prior to any X which is a #$TurningOnAnElectricalSwitch, the switch involved has (#$fromState X #$DeviceOff).") ;;; #$genFormat (#$isa #$genFormat #$TernaryPredicate) (#$arg1Isa #$genFormat #$Relationship) (#$arg2Isa #$genFormat #$CycSystemString) (#$arg3Isa #$genFormat #$CycSystemList) ;;; #$genMassNoun (#$isa #$genMassNoun #$UnaryPredicate) (#$arg1Isa #$genMassNoun #$ReifiableTerm) (#$comment #$genMassNoun "This predicate is a flag to indicate when a given constant should be treated as a mass noun in English paraphrases. See also #$prettyName.") ;;; #$genlAttributes (#$not (#$isa #$genlAttributes #$AsymmetricBinaryPredicate)) (#$not (#$isa #$genlAttributes #$AntiSymmetricBinaryPredicate)) (#$not (#$isa #$genlAttributes #$SymmetricBinaryPredicate)) (#$isa #$genlAttributes #$RuleMacroPredicate) (#$isa #$genlAttributes #$IntangibleObjectPredicate) (#$isa #$genlAttributes #$TransitiveBinaryPredicate) (#$isa #$genlAttributes #$ReflexiveBinaryPredicate) (#$arg1Isa #$genlAttributes #$AttributeValue) (#$arg2Isa #$genlAttributes #$AttributeValue) (#$comment #$genlAttributes "(#$genlAttributes S-ATT G-ATT) means that G-ATT is a more general attribute than S-ATT. If we know, for some object, THING, (#$hasAttributes THING S-ATT), the system will be able to derive (#$hasAttributes THING G-ATT). #$genlAttributes is transitive, so (#$genlAttributes A B) and (#$genlAttributes B C) lets the system derive (#$genlAttributes A C). For example, if a certain portion of the atmosphere has the attribute #$Hazy, Cyc can conclude through its #$genlAttributes knowledge that there is only moderate #$Visibility there.") ;;; #$genlInverse (#$not (#$isa #$genlInverse #$IrreflexiveBinaryPredicate)) (#$not (#$isa #$genlInverse #$ReflexiveBinaryPredicate)) (#$not (#$isa #$genlInverse #$AsymmetricBinaryPredicate)) (#$not (#$isa #$genlInverse #$AntiSymmetricBinaryPredicate)) (#$not (#$isa #$genlInverse #$SymmetricBinaryPredicate)) (#$not (#$isa #$genlInverse #$TransitiveBinaryPredicate)) (#$isa #$genlInverse #$RuleMacroPredicate) (#$isa #$genlInverse #$BinaryPredicate) (#$arg1Isa #$genlInverse #$BinaryPredicate) (#$arg2Isa #$genlInverse #$BinaryPredicate) (#$comment #$genlInverse "(#$genlInverse NARROW BROAD) means that binary predicate BROAD is a more general version of binary predicate NARROW, but with the arguments reversed. Thus (NARROW ARG1 ARG2) implies (BROAD ARG2 ARG1). Note: Notice that if two predicates are true inverses of each other, such as the pair parents and children, or the pair greater-than and less-than, then each member of the pair will be a #$genlInverse of the other. Creating two predicates like that is considered poor KEing style, however, because in that case the second predicate in the pair adds no new `expressive power' over what the first already provides. One might decide to write an end-user interface which acts as though both predicates exist, so that the user doesn't have to remember which is `the real one' in the system, but there is no gain at the representation language level to having both predicates.") ;;; #$genlMt (#$isa #$genlMt #$TransitiveBinaryPredicate) (#$isa #$genlMt #$ReflexiveBinaryPredicate) (#$isa #$genlMt #$AntiSymmetricBinaryPredicate) (#$isa #$genlMt #$DefaultMonotonicPredicate) (#$isa #$genlMt #$MicrotheoryPredicate) (#$isa #$genlMt #$RuleMacroPredicate) (#$arg1Isa #$genlMt #$Microtheory) (#$arg2Isa #$genlMt #$Microtheory) (#$comment #$genlMt "(#$genlMt SMT GMT) means #$Microtheory SMT is a specialization of #$Microtheory GMT. E.g., (#$genlMt #$ModernMilitaryMt #$OrganizationMt), which means that all the assertions which are true `content' in the general #$OrganizationMt context are also true in the more specialized #$ModernMilitaryMt context. Another way to think of this is that SMT `has access to' the content of GMT. Each proposition which is true in GMT is also true in SMT. The #$genlMt relation is transitive; it induces a partial ordering on the set of all microtheories. Each assertion in the knowledge base must be explicitly stated to be true in at least one mt. It will then (by inference) also be true in all the more specialized contexts. If something is true in the `life in North America' mt, then it should by default be true in the `life in Canada' mt. I.e., the microtheories are organized into a generalization/specialization lattice by the predicate #$genlMt, just as collections are organized into such a lattice by #$genls, and just as predicates are organized into such a lattice by #$genlPreds. Just as a collection may have several incommensurable supersets, so too a microtheory may have several incommensurable #$genlMts. Just as each and every collection must have some explicitly recorded superset (except for #$Thing), each and every mt must have some (expicitly recorded) more general mt (except for the #$BaseKB, which is the most general context, containing universal, timeless truths). Just as a Cyc concept may have multiple incommensurable sets of which it is an element (via #$isa), so too a Cyc assertion may be declared to be true in a set of incommensurable mts. For virtually all intents and purposes, #$genlMt assertions should go in #$BaseKB.") ;;; #$genlPreds (#$isa #$genlPreds #$RuleMacroPredicate) (#$isa #$genlPreds #$TransitiveBinaryPredicate) (#$isa #$genlPreds #$ReflexiveBinaryPredicate) (#$isa #$genlPreds #$AntiSymmetricBinaryPredicate) (#$arg1Isa #$genlPreds #$Predicate) (#$arg2Isa #$genlPreds #$Predicate) (#$comment #$genlPreds "(#$genlPreds NARROW BROAD) means that predicate BROAD is a more general version of predicate NARROW; e.g., (#$genlPreds #$biologicalMother #$biologicalParents), (#$genlPreds #$greaterThan #$greaterThanOrEqualTo). (#$genlPreds NARROW BROAD) is shorthand for the axiom schema (NARROW ARG1 ... ARGN) |=produces= (BROAD ARG1 ... ARGN). See also #$genlInverse, which can handle cases where NARROW and BROAD are both binary but their order of arguments is reversed. If the #$arity of NARROW differs from the #$arity of BROAD (or their order of arguments differs and they're not binary), then we just assert the whole appropriate axiom into the Cyc knowledge base; of course, such axioms are absent from the public release of the Upper Cyc Ontology.") ;;; #$genls (#$not (#$isa #$genls #$AsymmetricBinaryPredicate)) (#$not (#$isa #$genls #$AntiSymmetricBinaryPredicate)) (#$not (#$isa #$genls #$SymmetricBinaryPredicate)) (#$isa #$genls #$RuleMacroPredicate) (#$isa #$genls #$TaxonomicSlotForCollections) (#$isa #$genls #$DefaultMonotonicPredicate) (#$isa #$genls #$ReflexiveBinaryPredicate) (#$isa #$genls #$TransitiveBinaryPredicate) (#$genlPreds #$genls #$subsetOf) (#$arg1Isa #$genls #$Collection) (#$arg2Isa #$genls #$Collection) (#$comment #$genls "(#$genls COL SUPER) means that SUPER is one of the supersets of COL. Both arguments must be elements of #$Collection. Cyc knows that #$genls is transitive; that is, if one asserts (#$genls COL SUPER) and (#$genls SUPER BIGGER), Cyc will infer that (#$genls COL BIGGER). Therefore, in practice one only manually asserts a small fraction of the #$genls assertions --- the vast majority are inferred automatically by Cyc.") ;;; #$geographicalSubRegions (#$isa #$geographicalSubRegions #$TransitiveBinaryPredicate) (#$isa #$geographicalSubRegions #$SpatialPredicate) (#$isa #$geographicalSubRegions #$ReflexiveBinaryPredicate) (#$genlPreds #$geographicalSubRegions #$surfaceParts) (#$genlInverse #$geographicalSubRegions #$inRegion) (#$arg1Isa #$geographicalSubRegions #$GeographicalRegion) (#$arg2Isa #$geographicalSubRegions #$GeographicalRegion) (#$comment #$geographicalSubRegions "(#$geographicalSubRegions SUPER SUB) means that SUPER and SUB are both elements of #$GeographicalRegion, and the area SUB lies wholly within the region SUPER (see #$inRegion). SUPER may or may not completely surround SUB (i.e., they may share an outer boundary, as do Texas and the USA). See also #$surroundsHorizontally, #$bordersOn.") ;;; #$gerund (#$isa #$gerund #$IntangibleObjectPredicate) (#$isa #$gerund #$BinaryPredicate) (#$arg1Isa #$gerund #$EnglishWord) (#$arg2Isa #$gerund #$CharacterString) (#$comment #$gerund "(#$gerund WORD STRING) means that STRING is the gerund form of WORD. Also known as present participle or progressive. The regular gerund is formed from the infinitive verb form with an `ing' suffix. Verbs in the Cyc lexicon will have a #$gerund entry only if they are irregular. Regular forms are generated by the morphology component. Regular example: `singing'. Irregular example: `swimming'.") ;;; #$goals (#$isa #$goals #$PropositionalAttitudeSlot) (#$genlPreds #$goals #$desires) (#$arg1Isa #$goals #$Agent) (#$arg2Isa #$goals #$Goal) (#$comment #$goals "(#$goals AGT G) means that the #$Agent AGT has the #$Goal G. That is, G is one of their goals. This implies (#$desires AGT G), but #$goals is stronger than #$desires, in that an agent will take action (or at least intend to take action, and plan accordingly) to make their #$goals true, while their #$desires may include things s/he merely wishes were true, but about which s/he has no intention of undertaking action. Additionally, #$goals are generally about the future, whereas #$desires can be about the present, future, or even the past. For further information about goals, see #$Goal. Also see #$intends.") ;;; #$governedByAgreement (#$isa #$governedByAgreement #$ActorSlot) (#$genlPreds #$governedByAgreement #$preActors) (#$arg1Isa #$governedByAgreement #$SocialOccurrence) (#$arg2Isa #$governedByAgreement #$Agreement) (#$comment #$governedByAgreement "The predicate #$governedByAgreement relates an event to an agreement which stipulates that certain conditions are to hold during that event. (#$governedByAgreement EVT AGR) means that some aspects of the #$SocialOccurrence EVT are controlled by the #$Agreement AGR. For example, a #$BuyingGroup may have #$SalesContracts with its #$suppliers that specify what prices may be charged for goods bought by members of the group during the agreement period.") ;;; #$government (#$isa #$government #$BinaryPredicate) (#$arg1Isa #$government #$GeopoliticalEntity) (#$arg2Isa #$government #$RegionalGovernment) (#$comment #$government "The predicate #$government identifies the political entity which has governing authority over a particular geopolitical region. (#$government GEOPOL GOV) means that the #$RegionalGovernment GOV is the government of the #$GeopoliticalEntity GEOPOL. That is, GOV claims to be the government of GEOPOL, is recognized as such at least informally, and effectively functions as such -- administering the internal and external affairs of GEOPOL -- whether or not GOV has formal diplomatic recognition. Effectively functioning as a #$government includes having the power to settle disputes, collect revenue, and provide services. Examples include the #$UnitedStatesFederalGovernment, the #$CityCouncilOfAustin (TX), and all of the entities returned by the Cyc function #$GovernmentFn (q.v.) -- e.g., (#$GovernmentFn #$Taiwan-RepublicOfChina), (#$GovernmentFn #$Russia).") ;;; #$governmentType (#$isa #$governmentType #$IntangibleObjectPredicate) (#$isa #$governmentType #$BinaryPredicate) (#$arg1Isa #$governmentType #$GeopoliticalEntity) (#$arg2Isa #$governmentType #$SystemOfGovernment) (#$comment #$governmentType "The predicate #$governmentType indicates what kind of system of government a geopolitical entity has. (#$governmentType REGION GOVSYSTEM) means that the government of the #$GeopoliticalEntity REGION is an element of the #$SystemOfGovernment type denoted by GOVSYSTEM. For example, the #$governmentType of the #$UnitedStatesOfAmerica is a #$FederalRepublic and a #$RepresentativeDemocracy.") ;;; #$grandchildren (#$isa #$grandchildren #$AsymmetricBinaryPredicate) (#$not (#$isa #$grandchildren #$TransitiveBinaryPredicate)) (#$genlPreds #$grandchildren #$relatives) (#$genlPreds #$grandchildren #$positiveVestedInterest) (#$arg1Isa #$grandchildren #$Animal) (#$arg2Isa #$grandchildren #$Animal) (#$comment #$grandchildren "(#$grandchildren PERSON1 PERSON2) means PERSON2 is the grandchild of PERSON1, howsoever the relationship is traced, biologically or through custom, rearing or adoption.") (#$comment #$grandchildren "(#$grandchildren OLDER YOUNGER) means YOUNGER is the biological grandchild of OLDER.") (#$comment #$grandchildren "(#$grandchildren OLDER YOUNGER) means YOUNGER is the grandchild of OLDER.") ;;; #$granuleOfStuff (#$isa #$granuleOfStuff #$BinaryPredicate) (#$arg1Isa #$granuleOfStuff #$ExistingStuffType) (#$arg2Isa #$granuleOfStuff #$ExistingObjectType) (#$arg2Genl #$granuleOfStuff #$PartiallyTangible) (#$comment #$granuleOfStuff "(#$granuleOfStuff STUFFTYPE OBJTYPE) means that the collection STUFFTYPE has as its spatial granules (or granularity level) the collection OBJTYPE. If some collection is spatially stuff-like, that means that the instances of that collection can be divided spatially, and the physical portions remaining will still be instances of that collection; e.g., a physcial portion of some instance of #$SandMob is still sand (cf. #$ExistingStuffType). Such division cannot go on indefinitely in this way, however: eventually, division of something spatially stuff-like will result in the object-like 'granules' out of which the stuff-like thing is composed. For instances, division of sand would eventually result in individual grains of sand, division of water would eventually get down to individual molecules of water, etc. At this level of division or below, the remaining physical portions do NOT count as instances of the stuff-type from which they were divided. This may seem counter-intuitive: isn't an individual molecule of water still water? Perhaps in some sense, but since the individual granules of a stuff typically do NOT have most of the properties that the groups made of the granules have (including the property of being stuff-like), we do not count the individual granules as instances of the collection of which they are granules.") ;;; #$granuleOfTime (#$isa #$granuleOfTime #$BinaryPredicate) (#$arg1Isa #$granuleOfTime #$TemporalStuffType) (#$arg2Isa #$granuleOfTime #$TemporalObjectType) (#$comment #$granuleOfTime "(#$granuleOfTime STUFFTYPE OBJTYPE) means that the collection STUFFTYPE has as its temporal granules (or granularity level) the collection OBJTYPE. If some collection is temporally stuff-like, that means that the instances of that collection can be divided temporally, and the temporal slices remaining will still be instances of that collection; e.g., a time slice of some instance of #$Person is still a person, and a temporal slice of a walking process is still a walking process (cf. #$TemporalStuffType). Such division cannot always go on indefinitely, however: eventually, division of something temporally stuff-like will result in the temporally object-like 'granules' out of which the stuff-like thing is composed. For instances, division of a walking process would eventually result in individual steps. At this level of division or below, the remaining temporal slices do NOT count as instances of the temporal stuff-type from which they were divided. This may seem counter-intuitive, but since the individual temporal granules of a temporal stuff typically do NOT have most of the properties that the groups made of the granules have (including the property of being temporally stuff-like), we do not count the individual granules as instances of the collection of which they are granules. See also #$granuleOfStuff.") ;;; #$greaterThan (#$isa #$greaterThan #$NumericComparison) (#$isa #$greaterThan #$EvaluatableFunction) (#$isa #$greaterThan #$TransitiveBinaryPredicate) (#$isa #$greaterThan #$AsymmetricBinaryPredicate) (#$arg1Isa #$greaterThan #$ScalarInterval) (#$arg2Isa #$greaterThan #$ScalarInterval) (#$comment #$greaterThan "The predicate #$greaterThan is Cyc's representation of the `greater than' relation in mathematics, adapted to use with Cyc's scalars, which include quantitative intervals as well as point values. Formally, there are two conditions under which (#$greaterThan SI-1 SI-2) is true, for two elements of #$ScalarInterval: (1) (#$followingValue SI-1 SI-2) is true, or (2) the minimum of SI-1 is greater than the maximum of SI-2. Note that `A is less than B' is expressed in CycL as (#$greaterThan B A).") (#$overlappingExternalConcept #$greaterThan #$SENSUS-Information1997 "GREATER-THAN") (#$synonymousExternalConcept #$greaterThan #$SENSUS-Information1997 "GREATER-THAN-COMPARISON") ;;; #$greaterThanOrEqualTo (#$isa #$greaterThanOrEqualTo #$NumericComparison) (#$isa #$greaterThanOrEqualTo #$EvaluatableFunction) (#$isa #$greaterThanOrEqualTo #$AntiSymmetricBinaryPredicate) (#$isa #$greaterThanOrEqualTo #$ReflexiveBinaryPredicate) (#$isa #$greaterThanOrEqualTo #$TransitiveBinaryPredicate) (#$arg1Isa #$greaterThanOrEqualTo #$ScalarInterval) (#$arg2Isa #$greaterThanOrEqualTo #$ScalarInterval) (#$comment #$greaterThanOrEqualTo "The predicate #$greaterThanOrEqualTo is Cyc's representation of the `greater than or equal to' relation in mathematics, adapted to use with Cyc's scalars, which include quantitative intervals as well as point values. (See #$ScalarInterval.) Formally, there are three conditions under which (#$greaterThanOrEqualTo SI-1 SI-2) is true, for two elements of #$ScalarInterval: (1) (#$equals SI-1 SI-2) is true; (2) (#$followingValue SI-1 SI-2) is true; or (3) the minimum of SI-1 is greater than or equal to the maximum of SI-2. Note that `A is less than or equal to B' is expressed in CycL as (#$greaterThanOrEqualTo B A).") (#$overlappingExternalConcept #$greaterThanOrEqualTo #$SENSUS-Information1997 "AT-LEAST") ;;; #$groundOf (#$isa #$groundOf #$BinaryPredicate) (#$isa #$groundOf #$SpatialPredicate) (#$arg1Isa #$groundOf #$PartiallyTangible) (#$arg2Isa #$groundOf #$Surface-Physical) (#$comment #$groundOf "(#$groundOf OBJ GROUND) means that GROUND is the stationary surface on which OBJ is located and possibly supported.") ;;; #$groupCardinality (#$isa #$groupCardinality #$IntervalBasedQuantitySlot) (#$arg1Isa #$groupCardinality #$Group) (#$arg2Isa #$groupCardinality #$NonNegativeInteger) (#$comment #$groupCardinality "The predicate #$groupCardinality is used to indicate the total number of members there are in a particular group. (#$groupCardinality GROUP INTEGER) means that the number of members in the #$Group GROUP is INTEGER. For example, the #$groupCardinality of the #$SevenWondersOfTheAncientWorld is 7. Cyc infers that the #$groupCardinality of any group that is a pair is 2, and that of a dozen is 12.") ;;; #$groupMemberType (#$isa #$groupMemberType #$BinaryPredicate) (#$arg1Isa #$groupMemberType #$Group) (#$arg2Isa #$groupMemberType #$ObjectType) (#$arg2Genl #$groupMemberType #$TemporalThing) (#$comment #$groupMemberType "The predicate #$groupMemberType is used in characterizing the members of a particular group. (#$groupMemberType GROUP TYPE) means that all of GROUP's members are elements of the collection TYPE. For example, to state that the #$groupMembers of the Austin City Council are humans, one would write (#$groupMemberType AustinCityCouncil #$Person). The members of a particular group might be characterized in more than one way; e.g., a Hispanic Business Council may have both the #$groupMemberType #$EthnicGroupOfHispanics and the #$groupMemberType #$BusinessPerson (provided that all of its members are Hispanic business people).") ;;; #$groupMembers (#$isa #$groupMembers #$CotemporalObjectsSlot) (#$genlPreds #$groupMembers #$cotemporal) (#$genlPreds #$groupMembers #$structureMembers) (#$arg1Isa #$groupMembers #$Group) (#$arg2Isa #$groupMembers #$TemporalThing) (#$comment #$groupMembers "The predicate #$groupMembers is used to relate a particular group to its individual members. (#$groupMembers GROUP MEMBER) means that MEMBER is a member of GROUP. For example, the #$PyramidOfCheops is a member of the #$SevenWondersOfTheAncientWorld. Or, to say that President Bill Clinton was a member of the Democratic Party throughout 1996, we would say: (#$holdsIn (#$YearFn 1996) (#$groupMembers #$DemocraticParty #$BillClinton)).") ;;; #$hairColor (#$isa #$hairColor #$TangibleObjectPredicate) (#$isa #$hairColor #$TernaryPredicate) (#$arg1Isa #$hairColor #$Mammal) (#$arg1Isa #$hairColor #$Animal) (#$arg2Isa #$hairColor #$ExistingObjectType) (#$arg2Genl #$hairColor #$AnimalBodyPart) (#$arg3Isa #$hairColor #$Color) (#$comment #$hairColor "(#$hairColor ANIMAL BODYPARTTYPE COLOR) means that the hair which the #$Animal ANIMAL has on its BODYPARTTYPE has the #$Color COLOR. E.g., (#$hairColor #$SantaClaus #$Chin #$WhiteColor). This is normally #$Mammal hair, but certain #$Invertebrates also have hair.") ;;; #$hangsAround (#$isa #$hangsAround #$IrreflexiveBinaryPredicate) (#$isa #$hangsAround #$AsymmetricBinaryPredicate) (#$not (#$isa #$hangsAround #$TransitiveBinaryPredicate)) (#$isa #$hangsAround #$ConnectionPredicate) (#$isa #$hangsAround #$SpatialPredicate) (#$genlPreds #$hangsAround #$hangsFrom) (#$genlPreds #$hangsAround #$on-Physical) (#$arg1Isa #$hangsAround #$SolidTangibleThing) (#$arg2Isa #$hangsAround #$SolidTangibleThing) (#$comment #$hangsAround "(#$hangsAround ?loop ?obj) means that ?loop is a semi-flexible loop, looped around a piece of ?obj. ?loop is supported by gripping friction and/or ?loop's limited ability to elongate as it moves down on ?obj. See also #$hangsFrom.") ;;; #$hangsFrom (#$isa #$hangsFrom #$AsymmetricBinaryPredicate) (#$isa #$hangsFrom #$TransitiveBinaryPredicate) (#$isa #$hangsFrom #$ConnectionPredicate) (#$isa #$hangsFrom #$SpatialPredicate) (#$genlPreds #$hangsFrom #$supportedBy) (#$arg1Isa #$hangsFrom #$SolidTangibleThing) (#$arg2Isa #$hangsFrom #$SolidTangibleThing) (#$comment #$hangsFrom "(#$hangsFrom ?obj1 ?obj2) means that ?obj1 is suspended from ?obj2, either directly touching it (like a weight attached to a line) or through some intermediary object (like a weight suspended from the ceiling). All of the weight of ?obj1 is #$supportedBy ?obj2. Most if not all of ?obj1 is below ?obj2. Certainly, the center of ?obj1 is below the connection point. If pushed, ?obj1 will undergo #$Swinging without necessarily dislodging it.") ;;; #$hardnessOfObject (#$isa #$hardnessOfObject #$TangibleObjectPredicate) (#$isa #$hardnessOfObject #$IntervalBasedQuantitySlot) (#$arg1Isa #$hardnessOfObject #$SolidTangibleThing) (#$arg2Isa #$hardnessOfObject #$Hardness) (#$comment #$hardnessOfObject "(#$hardnessOfObject OBJ DEGREE) means that the instance of #$SolidTangibleThing OBJ has this DEGREE of #$Hardness.") ;;; #$hasAsTributary (#$isa #$hasAsTributary #$PhysicalPartPredicate) (#$isa #$hasAsTributary #$AsymmetricBinaryPredicate) (#$arg1Isa #$hasAsTributary #$River) (#$arg2Isa #$hasAsTributary #$River) (#$comment #$hasAsTributary "The predicate #$hasAsTributary is used to indicate the tributaries of a particular river. (#$hasAsTributary BIGRIV SMALLRIV) means that BIGRIV has SMALLRIV as one of its tributaries. SMALLRIV flows into BIGRIV. Examples: the #$MississippiRiver has the #$WisconsinRiver, #$OhioRiver, #$ArkansasRiver, #$RedRiverOfTexas, and others as its tributaries. Cf. #$formedByConfluenceOf.")